1   /**
2    * Copyright 2014 Netflix, Inc.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    * http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package rx.internal.operators;
17  
18  import static org.junit.Assert.assertEquals;
19  import static org.mockito.Matchers.isA;
20  import static org.mockito.Mockito.inOrder;
21  import static org.mockito.Mockito.mock;
22  import static org.mockito.Mockito.times;
23  
24  import java.util.NoSuchElementException;
25  
26  import org.junit.Test;
27  import org.mockito.InOrder;
28  
29  import rx.Observable;
30  import rx.Observer;
31  import rx.functions.Func1;
32  
33  public class OperatorLastTest {
34  
35      @Test
36      public void testLastWithElements() {
37          Observable<Integer> last = Observable.just(1, 2, 3).last();
38          assertEquals(3, last.toBlocking().single().intValue());
39      }
40  
41      @Test(expected = NoSuchElementException.class)
42      public void testLastWithNoElements() {
43          Observable<?> last = Observable.empty().last();
44          last.toBlocking().single();
45      }
46  
47      @Test
48      public void testLastMultiSubscribe() {
49          Observable<Integer> last = Observable.just(1, 2, 3).last();
50          assertEquals(3, last.toBlocking().single().intValue());
51          assertEquals(3, last.toBlocking().single().intValue());
52      }
53  
54      @Test
55      public void testLastViaObservable() {
56          Observable.just(1, 2, 3).last();
57      }
58  
59      @Test
60      public void testLast() {
61          Observable<Integer> observable = Observable.just(1, 2, 3).last();
62  
63          @SuppressWarnings("unchecked")
64          Observer<Integer> observer = mock(Observer.class);
65          observable.subscribe(observer);
66  
67          InOrder inOrder = inOrder(observer);
68          inOrder.verify(observer, times(1)).onNext(3);
69          inOrder.verify(observer, times(1)).onCompleted();
70          inOrder.verifyNoMoreInteractions();
71      }
72  
73      @Test
74      public void testLastWithOneElement() {
75          Observable<Integer> observable = Observable.just(1).last();
76  
77          @SuppressWarnings("unchecked")
78          Observer<Integer> observer = mock(Observer.class);
79          observable.subscribe(observer);
80  
81          InOrder inOrder = inOrder(observer);
82          inOrder.verify(observer, times(1)).onNext(1);
83          inOrder.verify(observer, times(1)).onCompleted();
84          inOrder.verifyNoMoreInteractions();
85      }
86  
87      @Test
88      public void testLastWithEmpty() {
89          Observable<Integer> observable = Observable.<Integer> empty().last();
90  
91          @SuppressWarnings("unchecked")
92          Observer<Integer> observer = mock(Observer.class);
93          observable.subscribe(observer);
94  
95          InOrder inOrder = inOrder(observer);
96          inOrder.verify(observer, times(1)).onError(
97                  isA(NoSuchElementException.class));
98          inOrder.verifyNoMoreInteractions();
99      }
100 
101     @Test
102     public void testLastWithPredicate() {
103         Observable<Integer> observable = Observable.just(1, 2, 3, 4, 5, 6)
104                 .last(new Func1<Integer, Boolean>() {
105 
106                     @Override
107                     public Boolean call(Integer t1) {
108                         return t1 % 2 == 0;
109                     }
110                 });
111 
112         @SuppressWarnings("unchecked")
113         Observer<Integer> observer = mock(Observer.class);
114         observable.subscribe(observer);
115 
116         InOrder inOrder = inOrder(observer);
117         inOrder.verify(observer, times(1)).onNext(6);
118         inOrder.verify(observer, times(1)).onCompleted();
119         inOrder.verifyNoMoreInteractions();
120     }
121 
122     @Test
123     public void testLastWithPredicateAndOneElement() {
124         Observable<Integer> observable = Observable.just(1, 2).last(
125                 new Func1<Integer, Boolean>() {
126 
127                     @Override
128                     public Boolean call(Integer t1) {
129                         return t1 % 2 == 0;
130                     }
131                 });
132 
133         @SuppressWarnings("unchecked")
134         Observer<Integer> observer = mock(Observer.class);
135         observable.subscribe(observer);
136 
137         InOrder inOrder = inOrder(observer);
138         inOrder.verify(observer, times(1)).onNext(2);
139         inOrder.verify(observer, times(1)).onCompleted();
140         inOrder.verifyNoMoreInteractions();
141     }
142 
143     @Test
144     public void testLastWithPredicateAndEmpty() {
145         Observable<Integer> observable = Observable.just(1).last(
146                 new Func1<Integer, Boolean>() {
147 
148                     @Override
149                     public Boolean call(Integer t1) {
150                         return t1 % 2 == 0;
151                     }
152                 });
153         @SuppressWarnings("unchecked")
154         Observer<Integer> observer = mock(Observer.class);
155         observable.subscribe(observer);
156 
157         InOrder inOrder = inOrder(observer);
158         inOrder.verify(observer, times(1)).onError(
159                 isA(NoSuchElementException.class));
160         inOrder.verifyNoMoreInteractions();
161     }
162 
163     @Test
164     public void testLastOrDefault() {
165         Observable<Integer> observable = Observable.just(1, 2, 3)
166                 .lastOrDefault(4);
167 
168         @SuppressWarnings("unchecked")
169         Observer<Integer> observer = mock(Observer.class);
170         observable.subscribe(observer);
171 
172         InOrder inOrder = inOrder(observer);
173         inOrder.verify(observer, times(1)).onNext(3);
174         inOrder.verify(observer, times(1)).onCompleted();
175         inOrder.verifyNoMoreInteractions();
176     }
177 
178     @Test
179     public void testLastOrDefaultWithOneElement() {
180         Observable<Integer> observable = Observable.just(1).lastOrDefault(2);
181 
182         @SuppressWarnings("unchecked")
183         Observer<Integer> observer = mock(Observer.class);
184         observable.subscribe(observer);
185 
186         InOrder inOrder = inOrder(observer);
187         inOrder.verify(observer, times(1)).onNext(1);
188         inOrder.verify(observer, times(1)).onCompleted();
189         inOrder.verifyNoMoreInteractions();
190     }
191 
192     @Test
193     public void testLastOrDefaultWithEmpty() {
194         Observable<Integer> observable = Observable.<Integer> empty()
195                 .lastOrDefault(1);
196 
197         @SuppressWarnings("unchecked")
198         Observer<Integer> observer = mock(Observer.class);
199         observable.subscribe(observer);
200 
201         InOrder inOrder = inOrder(observer);
202         inOrder.verify(observer, times(1)).onNext(1);
203         inOrder.verify(observer, times(1)).onCompleted();
204         inOrder.verifyNoMoreInteractions();
205     }
206 
207     @Test
208     public void testLastOrDefaultWithPredicate() {
209         Observable<Integer> observable = Observable.just(1, 2, 3, 4, 5, 6)
210                 .lastOrDefault(8, new Func1<Integer, Boolean>() {
211 
212                     @Override
213                     public Boolean call(Integer t1) {
214                         return t1 % 2 == 0;
215                     }
216                 });
217 
218         @SuppressWarnings("unchecked")
219         Observer<Integer> observer = mock(Observer.class);
220         observable.subscribe(observer);
221 
222         InOrder inOrder = inOrder(observer);
223         inOrder.verify(observer, times(1)).onNext(6);
224         inOrder.verify(observer, times(1)).onCompleted();
225         inOrder.verifyNoMoreInteractions();
226     }
227 
228     @Test
229     public void testLastOrDefaultWithPredicateAndOneElement() {
230         Observable<Integer> observable = Observable.just(1, 2).lastOrDefault(4,
231                 new Func1<Integer, Boolean>() {
232 
233                     @Override
234                     public Boolean call(Integer t1) {
235                         return t1 % 2 == 0;
236                     }
237                 });
238 
239         @SuppressWarnings("unchecked")
240         Observer<Integer> observer = mock(Observer.class);
241         observable.subscribe(observer);
242 
243         InOrder inOrder = inOrder(observer);
244         inOrder.verify(observer, times(1)).onNext(2);
245         inOrder.verify(observer, times(1)).onCompleted();
246         inOrder.verifyNoMoreInteractions();
247     }
248 
249     @Test
250     public void testLastOrDefaultWithPredicateAndEmpty() {
251         Observable<Integer> observable = Observable.just(1).lastOrDefault(2,
252                 new Func1<Integer, Boolean>() {
253 
254                     @Override
255                     public Boolean call(Integer t1) {
256                         return t1 % 2 == 0;
257                     }
258                 });
259 
260         @SuppressWarnings("unchecked")
261         Observer<Integer> observer = mock(Observer.class);
262         observable.subscribe(observer);
263 
264         InOrder inOrder = inOrder(observer);
265         inOrder.verify(observer, times(1)).onNext(2);
266         inOrder.verify(observer, times(1)).onCompleted();
267         inOrder.verifyNoMoreInteractions();
268     }
269 }